home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / p_man / cat3 / SCSL / clatps.z / clatps
Encoding:
Text File  |  2002-10-03  |  8.6 KB  |  265 lines
  1.  
  2.  
  3.  
  4. CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))                                                          CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      CLATPS - solve one of the triangular systems  A * x = s*b, A**T * x =
  10.      s*b, or A**H * x = s*b,
  11.  
  12. SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
  13.      SUBROUTINE CLATPS( UPLO, TRANS, DIAG, NORMIN, N, AP, X, SCALE, CNORM,
  14.                         INFO )
  15.  
  16.          CHARACTER      DIAG, NORMIN, TRANS, UPLO
  17.  
  18.          INTEGER        INFO, N
  19.  
  20.          REAL           SCALE
  21.  
  22.          REAL           CNORM( * )
  23.  
  24.          COMPLEX        AP( * ), X( * )
  25.  
  26. IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
  27.      These routines are part of the SCSL Scientific Library and can be loaded
  28.      using either the -lscs or the -lscs_mp option.  The -lscs_mp option
  29.      directs the linker to use the multi-processor version of the library.
  30.  
  31.      When linking to SCSL with -lscs or -lscs_mp, the default integer size is
  32.      4 bytes (32 bits). Another version of SCSL is available in which integers
  33.      are 8 bytes (64 bits).  This version allows the user access to larger
  34.      memory sizes and helps when porting legacy Cray codes.  It can be loaded
  35.      by using the -lscs_i8 option or the -lscs_i8_mp option. A program may use
  36.      only one of the two versions; 4-byte integer and 8-byte integer library
  37.      calls cannot be mixed.
  38.  
  39. PPPPUUUURRRRPPPPOOOOSSSSEEEE
  40.      CLATPS solves one of the triangular systems A * x = s*b, A**T * x = s*b,
  41.      or A**H * x = s*b, with scaling to prevent overflow, where A is an upper
  42.      or lower triangular matrix stored in packed form.  Here A**T denotes the
  43.      transpose of A, A**H denotes the conjugate transpose of A, x and b are
  44.      n-element vectors, and s is a scaling factor, usually less than or equal
  45.      to 1, chosen so that the components of x will be less than the overflow
  46.      threshold.  If the unscaled problem will not cause overflow, the Level 2
  47.      BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for
  48.      some j), then s is set to 0 and a non-trivial solution to A*x = 0 is
  49.      returned.
  50.  
  51.  
  52. AAAARRRRGGGGUUUUMMMMEEEENNNNTTTTSSSS
  53.      UPLO    (input) CHARACTER*1
  54.              Specifies whether the matrix A is upper or lower triangular.  =
  55.              'U':  Upper triangular
  56.              = 'L':  Lower triangular
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))                                                          CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))
  71.  
  72.  
  73.  
  74.      TRANS   (input) CHARACTER*1
  75.              Specifies the operation applied to A.  = 'N':  Solve A * x = s*b
  76.              (No transpose)
  77.              = 'T':  Solve A**T * x = s*b  (Transpose)
  78.              = 'C':  Solve A**H * x = s*b  (Conjugate transpose)
  79.  
  80.      DIAG    (input) CHARACTER*1
  81.              Specifies whether or not the matrix A is unit triangular.  = 'N':
  82.              Non-unit triangular
  83.              = 'U':  Unit triangular
  84.  
  85.      NORMIN  (input) CHARACTER*1
  86.              Specifies whether CNORM has been set or not.  = 'Y':  CNORM
  87.              contains the column norms on entry
  88.              = 'N':  CNORM is not set on entry.  On exit, the norms will be
  89.              computed and stored in CNORM.
  90.  
  91.      N       (input) INTEGER
  92.              The order of the matrix A.  N >= 0.
  93.  
  94.      AP      (input) COMPLEX array, dimension (N*(N+1)/2)
  95.              The upper or lower triangular matrix A, packed columnwise in a
  96.              linear array.  The j-th column of A is stored in the array AP as
  97.              follows:  if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
  98.              if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
  99.  
  100.      X       (input/output) COMPLEX array, dimension (N)
  101.              On entry, the right hand side b of the triangular system.  On
  102.              exit, X is overwritten by the solution vector x.
  103.  
  104.      SCALE   (output) REAL
  105.              The scaling factor s for the triangular system A * x = s*b,  A**T
  106.              * x = s*b,  or  A**H * x = s*b.  If SCALE = 0, the matrix A is
  107.              singular or badly scaled, and the vector x is an exact or
  108.              approximate solution to A*x = 0.
  109.  
  110.      CNORM   (input or output) REAL array, dimension (N)
  111.  
  112.              If NORMIN = 'Y', CNORM is an input argument and CNORM(j) contains
  113.              the norm of the off-diagonal part of the j-th column of A.  If
  114.              TRANS = 'N', CNORM(j) must be greater than or equal to the
  115.              infinity-norm, and if TRANS = 'T' or 'C', CNORM(j) must be
  116.              greater than or equal to the 1-norm.
  117.  
  118.              If NORMIN = 'N', CNORM is an output argument and CNORM(j) returns
  119.              the 1-norm of the offdiagonal part of the j-th column of A.
  120.  
  121.      INFO    (output) INTEGER
  122.              = 0:  successful exit
  123.              < 0:  if INFO = -k, the k-th argument had an illegal value
  124.  
  125.  
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))                                                          CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))
  137.  
  138.  
  139.  
  140. FFFFUUUURRRRTTTTHHHHEEEERRRR DDDDEEEETTTTAAAAIIIILLLLSSSS
  141.      A rough bound on x is computed; if that is less than overflow, CTPSV is
  142.      called, otherwise, specific code is used which checks for possible
  143.      overflow or divide-by-zero at every operation.
  144.  
  145.      A columnwise scheme is used for solving A*x = b.  The basic algorithm if
  146.      A is lower triangular is
  147.  
  148.           x[1:n] := b[1:n]
  149.           for j = 1, ..., n
  150.                x(j) := x(j) / A(j,j)
  151.                x[j+1:n] := x[j+1:n] - x(j) * A[j+1:n,j]
  152.           end
  153.  
  154.      Define bounds on the components of x after j iterations of the loop:
  155.         M(j) = bound on x[1:j]
  156.         G(j) = bound on x[j+1:n]
  157.      Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.
  158.  
  159.      Then for iteration j+1 we have
  160.         M(j+1) <= G(j) / | A(j+1,j+1) |
  161.         G(j+1) <= G(j) + M(j+1) * | A[j+2:n,j+1] |
  162.                <= G(j) ( 1 + CNORM(j+1) / | A(j+1,j+1) | )
  163.  
  164.      where CNORM(j+1) is greater than or equal to the infinity-norm of column
  165.      j+1 of A, not counting the diagonal.  Hence
  166.  
  167.         G(j) <= G(0) product ( 1 + CNORM(i) / | A(i,i) | )
  168.                      1<=i<=j
  169.      and
  170.  
  171.         |x(j)| <= ( G(0) / |A(j,j)| ) product ( 1 + CNORM(i) / |A(i,i)| )
  172.                                       1<=i< j
  173.  
  174.      Since |x(j)| <= M(j), we use the Level 2 BLAS routine CTPSV if the
  175.      reciprocal of the largest M(j), j=1,..,n, is larger than
  176.      max(underflow, 1/overflow).
  177.  
  178.      The bound on x(j) is also used to determine when a step in the columnwise
  179.      method can be performed without fear of overflow.  If the computed bound
  180.      is greater than a large constant, x is scaled to prevent overflow, but if
  181.      the bound overflows, x is set to 0, x(j) to 1, and scale to 0, and a
  182.      non-trivial solution to A*x = 0 is found.
  183.  
  184.      Similarly, a row-wise scheme is used to solve A**T *x = b  or A**H *x =
  185.      b.  The basic algorithm for A upper triangular is
  186.  
  187.           for j = 1, ..., n
  188.                x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
  189.           end
  190.  
  191.      We simultaneously compute two bounds
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))                                                          CCCCLLLLAAAATTTTPPPPSSSS((((3333SSSS))))
  203.  
  204.  
  205.  
  206.           G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
  207.           M(j) = bound on x(i), 1<=i<=j
  208.  
  209.      The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we add
  210.      the constraint G(j) >= G(j-1) and M(j) >= M(j-1) for j >= 1.  Then the
  211.      bound on x(j) is
  212.  
  213.           M(j) <= M(j-1) * ( 1 + CNORM(j) ) / | A(j,j) |
  214.  
  215.                <= M(0) * product ( ( 1 + CNORM(i) ) / |A(i,i)| )
  216.                          1<=i<=j
  217.  
  218.      and we can safely call CTPSV if 1/M(n) and 1/G(n) are both greater than
  219.      max(underflow, 1/overflow).
  220.  
  221.  
  222. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  223.      INTRO_LAPACK(3S), INTRO_SCSL(3S)
  224.  
  225.      This man page is available only online.
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.                                                                         PPPPaaaaggggeeee 4444
  262.  
  263.  
  264.  
  265.